"""
数据处理器模块
用于处理和转换数据
"""

import time
import json
import logging
from typing import Dict, List, Any, Optional
from datetime import datetime

from .api_client import ApiClient
from .cache_manager import CacheManager

logger = logging.getLogger(__name__)

def format_timestamp(timestamp: float) -> str:
    """
    格式化时间戳为可读字符串
    
    Args:
        timestamp: Unix时间戳
        
    Returns:
        格式化的时间字符串
    """
    dt = datetime.fromtimestamp(timestamp)
    return dt.strftime("%Y-%m-%d %H:%M:%S")

def calculate_statistics(values: List[float]) -> Dict[str, float]:
    """
    计算统计数据
    
    Args:
        values: 数值列表
        
    Returns:
        包含统计结果的字典
    """
    if not values:
        return {"count": 0, "min": 0, "max": 0, "avg": 0, "sum": 0}
    
    return {
        "count": len(values),
        "min": min(values),
        "max": max(values),
        "avg": sum(values) / len(values),
        "sum": sum(values)
    }

class DataProcessor:
    """数据处理器，用于处理和转换数据"""
    
    def __init__(self, config: Dict[str, Any]):
        """
        初始化数据处理器
        
        Args:
            config: 配置字典
        """
        self.config = config
        self.api_client = ApiClient(
            config["api_url"],
            timeout=config["timeout"]
        )
        self.cache = CacheManager(
            config["cache_dir"],
            max_age=config.get("cache_max_age", 3600)
        )
    
    def fetch_data(self, endpoint: str, params: Optional[Dict[str, Any]] = None, use_cache: bool = True) -> Dict[str, Any]:
        """
        获取数据，支持缓存
        
        Args:
            endpoint: API端点
            params: 查询参数
            use_cache: 是否使用缓存
            
        Returns:
            API响应数据
        """
        # 构建缓存键
        cache_key = f"{endpoint}:{json.dumps(params or {})}"
        
        # 尝试从缓存获取
        if use_cache:
            cached_data = self.cache.get(cache_key)
            if cached_data is not None:
                logger.debug(f"从缓存获取数据: {endpoint}")
                return cached_data
        
        # 从API获取
        logger.debug(f"从API获取数据: {endpoint}")
        data = self.api_client.fetch_with_retry(endpoint, params)
        
        # 缓存结果
        if use_cache:
            self.cache.set(cache_key, data)
        
        return data
    
    def process_items(self, items: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
        """
        处理项目列表
        
        Args:
            items: 项目列表
            
        Returns:
            处理后的项目列表
        """
        result = []
        
        for item in items:
            # 深拷贝，避免修改原始数据
            processed = dict(item)
            
            # 添加处理时间戳
            processed["processed_at"] = time.time()
            
            # 格式化日期字段
            if "created_at" in processed and isinstance(processed["created_at"], (int, float)):
                processed["created_at_formatted"] = format_timestamp(processed["created_at"])
            
            # 计算派生字段
            if "values" in processed and isinstance(processed["values"], list):
                processed["statistics"] = calculate_statistics(processed["values"])
            
            result.append(processed)
        
        return result
    
    def filter_items(self, items: List[Dict[str, Any]], criteria: Dict[str, Any]) -> List[Dict[str, Any]]:
        """
        根据条件过滤项目
        
        Args:
            items: 项目列表
            criteria: 过滤条件
            
        Returns:
            过滤后的项目列表
        """
        result = []
        
        for item in items:
            match = True
            
            for key, value in criteria.items():
                if key not in item or item[key] != value:
                    match = False
                    break
            
            if match:
                result.append(item)
        
        return result
    
    def sort_items(self, items: List[Dict[str, Any]], key: str, reverse: bool = False) -> List[Dict[str, Any]]:
        """
        排序项目
        
        Args:
            items: 项目列表
            key: 排序键
            reverse: 是否降序
            
        Returns:
            排序后的项目列表
        """
        return sorted(items, key=lambda x: x.get(key, 0), reverse=reverse)
    
    def group_items(self, items: List[Dict[str, Any]], key: str) -> Dict[str, List[Dict[str, Any]]]:
        """
        按键分组项目
        
        Args:
            items: 项目列表
            key: 分组键
            
        Returns:
            分组后的字典，键为分组值，值为项目列表
        """
        result = {}
        
        for item in items:
            group_value = item.get(key, "unknown")
            if group_value not in result:
                result[group_value] = []
            result[group_value].append(item)
        
        return result
    
    def aggregate_by_group(self, grouped_items: Dict[str, List[Dict[str, Any]]], value_key: str) -> Dict[str, Dict[str, float]]:
        """
        对分组数据进行聚合计算
        
        Args:
            grouped_items: 分组后的项目字典
            value_key: 值键名
            
        Returns:
            聚合结果字典
        """
        result = {}
        
        for group_key, items in grouped_items.items():
            values = [item.get(value_key, 0) for item in items if value_key in item]
            result[group_key] = calculate_statistics(values)
        
        return result
    
    def export_to_json(self, data: Any, file_path: str) -> bool:
        """
        导出数据到JSON文件
        
        Args:
            data: 要导出的数据
            file_path: 文件路径
            
        Returns:
            是否成功
        """
        try:
            with open(file_path, 'w') as f:
                json.dump(data, f, indent=2)
            return True
        except Exception as e:
            logger.error(f"导出JSON失败: {e}")
            return False
    
    def export_to_csv(self, items: List[Dict[str, Any]], file_path: str, fields: Optional[List[str]] = None) -> bool:
        """
        导出数据到CSV文件
        
        Args:
            items: 项目列表
            file_path: 文件路径
            fields: 要导出的字段列表，如果为None则导出所有字段
            
        Returns:
            是否成功
        """
        if not items:
            logger.warning("没有数据可导出")
            return False
        
        try:
            import csv
            
            # 如果未指定字段，使用第一个项目的所有键
            if fields is None:
                fields = list(items[0].keys())
            
            with open(file_path, 'w', newline='') as f:
                writer = csv.DictWriter(f, fieldnames=fields, extrasaction='ignore')
                writer.writeheader()
                writer.writerows(items)
            
            return True
        except Exception as e:
            logger.error(f"导出CSV失败: {e}")
            return False